import java.awt.List;
import java.io.Serializable;
import java.util.Collection;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Classe controleur et application (syst�me)
 * 
 * @author IUT, A. Culet
 * @version 1.0
 */

// public class Controleur extends Observable implements Serializable{
public class Controleur implements Serializable {

	private static final long serialVersionUID = 1L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation Elle est
	 * également la classe "application" qui gère l'ensemble des objets de
	 * l'appli
	 */
	// ************************************************************************************************************
	// Attributs
	// ************************************************************************************************************

	// Attributs d'Association
	// Ensemble des ouvrages de la biblioth�que
	private HashMap<String, Ouvrage> _ouvrages;
	// Ensemble des documents de la biblioth�que
		private HashMap<String, Document> _documents;
	// Ensemble des auteurs de la biblioth�que
	private HashMap<Integer, Auteur> _auteurs;
	// Ensemble des Periodique de la biblioth�que
	private HashMap<Integer, Periodique> _periodiques;
	// Ensemble des articles de la biblioth�que
	private HashMap<Integer, Article> _articles;
		
	// les diff�rentes fen�tres pour chaque fonctionnalit�
	private VueMenuBiblio _vueMenuBiblio = null;

	// une seule fen�tre est active � la fois; les autres sont à null.
	// permet de connaître l'état des fenêtres de l'interface
	private VueSaisieOuvrage _vueSaisieOuvrage = null;
	private VueSaisiePeriodique _vueSaisiePeriodique = null;
	private VueSaisieExemplaire _vueSaisieExemplaire = null;
	private VueConsultOuvrage _vueConsultOuvrage = null;
	private VueSaisieAuteur _vueSaisieAuteur = null;
	private VueSaisieParution _vueSaisieParution = null;
	private VueSaisieArticle _vueSaisieArticle = null;
	private VueRechercheParAuteur _vueRechercheParAuteur = null;
	private VueConsultPerdiodique _vueConsultPeriodique = null;
	private VueRechercheMotTitre _vueRechercheMotTitre = null;

	// ************************************************************************************************************
	// Constructeur
	// ************************************************************************************************************

	public Controleur() {
		this.setOuvrages(new HashMap<String, Ouvrage>());
		this.setArticles(new HashMap<Integer, Article>());
		this.setPeriodiques(new HashMap<Integer, Periodique>());
		this.setAuteurs(new HashMap<Integer, Auteur>());
	} // Fin Controleur

	// ************************************************************************************************************
	// M�thodes priv�es
	// ************************************************************************************************************

	// ------------------------------------------------------------------------------------------------------------
	// Affecteurs

	/**
	 * Ajoute un ouvrage à l'ensemble des ouvrages de la bibliothèque
	 * 
	 * @param ouvrage
	 *            Ouvrage à ajouter
	 * @param isbn
	 *            code ISBN de cet ouvrage
	 */
	private void setOuvrage(Ouvrage ouvrage, String isbn) {
		this.getOuvrages().put(isbn, ouvrage);
	} // Fin setOuvrage
	
	private void setArticle(Article art,Integer num){
		this.getArticles().put(num, art);
	}

	private void setArticles(HashMap<Integer,Article> art) {
		_articles = art;
	}
	/**
	 * @param ouvrages
	 *            hashtable d'ouvrages à affecter
	 */
	private void setOuvrages(HashMap<String, Ouvrage> ouvrages) {
		_ouvrages = ouvrages;
	}// Fin setOuvrages

	private void setDocument(Document doc, String titre) {
		this.getDocuments().put(titre, doc);
	} // Fin setOuvrage

	/**
	 * @param ouvrages
	 *            hashtable d'ouvrages à affecter
	 */
	private void setDocuments(HashMap<String, Document> documents) {
		_documents = documents;
	}// Fin setDocument
	
	private void setPeriodique(Periodique periodique, int num) {
		this.getPeriodiques().put(num, periodique);
	}

	private void setPeriodiques(HashMap<Integer, Periodique> periodiques) {
		_periodiques = periodiques;
	}

	private void setAuteur(int num, Auteur auteur) {
		this.getAuteurs().put(num, auteur);
	}

	private void setAuteurs(HashMap<Integer, Auteur> auteurs) {
		_auteurs = auteurs;
	}// Fin setOuvrages

	/**
	 * @param vue
	 *            la vue à affecter
	 */
	private void setVueMenuBiblio(VueMenuBiblio vue) {
		_vueMenuBiblio = vue;
	}// Fin getVueVueMenuBiblio

	private void setVueSaisieOuvrage(VueSaisieOuvrage vue) {
		_vueSaisieOuvrage = vue;
	}// Fin setVueVueSaisieOuvrage

	private void setVueSaisieExemplaire(VueSaisieExemplaire vue) {
		_vueSaisieExemplaire = vue;
	}// Fin setVueVueSaisieExemplaire

	private void setVueConsultOuvrage(VueConsultOuvrage vue) {
		_vueConsultOuvrage = vue;
	}// Fin setVueVueConsultOuvrage

	private void setVueSaisiePeriodique(VueSaisiePeriodique vue) {
		_vueSaisiePeriodique = vue;
	}

	private void setVueSaisieAuteur(VueSaisieAuteur vue) {
		_vueSaisieAuteur = vue;
	}

	private void setVueSaisieParution(VueSaisieParution vue) {
		_vueSaisieParution = vue;
	}
	
	private void setVueSaisieArticle(VueSaisieArticle vue){
		_vueSaisieArticle = vue;
	}

	private void setVueRechercheParAuteur(VueRechercheParAuteur vue){
		_vueRechercheParAuteur = vue;
	}
	
	private void setVueConsultPeriodique(VueConsultPerdiodique vue){
		_vueConsultPeriodique = vue;
	}
	
	private void setVueRechercheMotTitre(VueRechercheMotTitre vue){
		_vueRechercheMotTitre = vue;
	}
	// ------------------------------------------------------------------------------------------------------------
	// Accesseurs

	/**
	 * @return ensemble des ouvrages de la bibliothèque
	 */
	public HashMap<String, Ouvrage> getOuvrages() {
		return _ouvrages;
	}// Fin getOuvrages

	/**
	 * Accès à un ouvrage par son numéro ISBN
	 * 
	 * @param isbn
	 *            le code ISBN de l'ouvrage cherché
	 * @return l'ouvrage qui a l'ISBN indiqué
	 */
	private Ouvrage getOuvrage(String isbn) {
		return this.getOuvrages().get(isbn);
	} // Fin getOuvrage
	
	public HashMap<String, Document> getDocuments() {
		return _documents;
	}// Fin getDocuments

	/**
	 * Accès à un Document par son titre
	 * 
	 * @param titre
	 *            
	 * @return le document qui a le titre indiqué
	 */
	public HashMap<Integer, Periodique> getPeriodiques() {
		return _periodiques;
	}

	public Collection<Periodique> getCollecPeriodique() {
		return _periodiques.values();
	}

	private Periodique getPeriodique(int num) {
		return this.getPeriodiques().get(num);
	}

	public HashMap<Integer, Article> getArticles() {
		return _articles;
	}

	private Article getArticle(int idArticle) {
		return this.getArticles().get(idArticle);
	}

	public HashMap<Integer, Auteur> getAuteurs() {
		return _auteurs;
	}

	private Auteur getAuteur(int num) {
		return this.getAuteurs().get(num);
	}
	
	/**
	 * @return la vue
	 */
	public VueMenuBiblio getVueMenuBiblio() {
		return _vueMenuBiblio;
	}// Fin getVueVueMenuBiblio

	public VueSaisieOuvrage getVueSaisieOuvrage() {
		return _vueSaisieOuvrage;
	}// Fin getVueVueSaisieOuvrage

	public VueSaisieExemplaire getVueSaisieExemplaire() {
		return _vueSaisieExemplaire;
	}// Fin getVueVueSaisieExemplaire

	public VueSaisiePeriodique getVueSaisiePeriodique() {
		return _vueSaisiePeriodique;
	}

	public VueConsultOuvrage getVueConsultOuvrage() {
		return _vueConsultOuvrage;
	}// Fin getVueVueConsultOuvrage

	public VueSaisieAuteur getVueSaisieAuteur() {
		return _vueSaisieAuteur;
	}

	public VueSaisieParution getVueSaisieParution() {
		return _vueSaisieParution;
	}
	
	public VueSaisieArticle getVueSaisieArticle(){
		return _vueSaisieArticle;
	}
	
	public VueRechercheParAuteur getVueRechercheParAuteur(){
		return _vueRechercheParAuteur;
	}
	
	public VueConsultPerdiodique getVueConsultPeriodique(){
		return _vueConsultPeriodique;
	}
	
	public VueRechercheMotTitre getVueRechercheMotTitre(){
		return _vueRechercheMotTitre;
	}
	// ************************************************************************************************************
	// Méthodes publiques de création et affichage des fenêtres de
	// l'application
	// et fermeture
	// ************************************************************************************************************
	/**
	 * Création et affichage de la fenêtre principale de l'application. Elle
	 * reste affichée
	 */

	public void menuBiblio() {
		try {
			this.setVueMenuBiblio(new VueMenuBiblio(this));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Création et affichage de la fenêtre de consultation d'un ouvrage
	 */

	public void consulterOuvrage() {
		try {
			this.setVueConsultOuvrage(new VueConsultOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueConsultOuvrage
			this.getVueConsultOuvrage().setEtat(Vue.initiale);
			this.getVueConsultOuvrage().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
	 */
	public void saisirExemplaire() {
		try {
			this.setVueSaisieExemplaire(new VueSaisieExemplaire(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieExemplaire
			this.getVueSaisieExemplaire().setEtat(Vue.initiale);
			this.getVueSaisieExemplaire().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Création et affichage de la fenêtre de saisie d'un ouvrage
	 */
	public void saisirOuvrage() {
		try {
			this.setVueSaisieOuvrage(new VueSaisieOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisieOuvrage().setEtat(Vue.initiale);
			this.getVueSaisieOuvrage().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void saisirPeriodique() {
		try {
			this.setVueSaisiePeriodique(new VueSaisiePeriodique(this));
			// le menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisiePeriodique().setEtat(Vue.initiale);
			this.getVueSaisiePeriodique().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void ajouterAuteur() {
		try {
			this.setVueSaisieAuteur(new VueSaisieAuteur(this));
			// le Menu est cach�
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieAuteur
			this.getVueSaisieAuteur().setEtat(Vue.initiale);
			this.getVueSaisieAuteur().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void saisirParution() {
		try {
			this.setVueSaisieParution(new VueSaisieParution(this));
			// le menu est cach�
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieParution
			this.getVueSaisieParution().setEtat(Vue.initiale);
			this.getVueSaisieParution().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void saisirArticle(Parution parution){
		try{
			this.setVueSaisieArticle(new VueSaisieArticle(parution, this));
			//
			//this.getVueSaisieParution().setVisible(false);
			//
			this.getVueSaisieArticle().setEtat(Vue.initiale);
			this.getVueSaisieArticle().setVisible(true);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}

	public void consulterPeriodique(){
		try{
			this.setVueConsultPeriodique(new VueConsultPerdiodique(this));
			//le menu est cache
			this.getVueMenuBiblio().getFrame().setVisible(false);
			this.getVueConsultPeriodique().setEtat(Vue.initiale);
			this.getVueConsultPeriodique().setVisible(true);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}
	public void rechercheParAuteur(){
		try{
			this.setVueRechercheParAuteur(new VueRechercheParAuteur(this));
			this.getVueMenuBiblio().getFrame().setVisible(false);
			this.getVueRechercheParAuteur().setEtat(Vue.initiale);
			this.getVueRechercheParAuteur().setVisible(true);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}
	/*public void rechercheParMotCle(){
		try{
			this.setRechercheParMotCle(new VueRechercheParMotCle(this));
			this.getVueRechercheParMotCle().setVisible(false);
			this.getVueRechercheParMotCle().setEtat(Vue.initiale);
			this.getVueRechercheParMotCle().setVisible(true);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}*/
	
	public void rechercheMotTitre(){
		try{
			this.setVueRechercheMotTitre(new VueRechercheMotTitre(this));
			this.getVueRechercheMotTitre().setVisible(false);
			this.getVueRechercheMotTitre().setEtat(Vue.initiale);
			this.getVueRechercheMotTitre().setVisible(true);
		}
		catch(Exception e){
			e.printStackTrace();
		}
	}
	
	/**
	 * fermeture de la fenêtre vue lors de la fermeture de la fenêtre principale
	 * de l'application sauvegarde des objets sérialisés
	 */
	public void fermerVue(Vue vue) {
		if (vue instanceof VueMenuBiblio) {
			// Quitte l'aplication. Sauvegarde les objets du modèle
			this.sauve();
			System.exit(0);
		}
		vue.dispose();
		// le Menu est rendu de nouveau visible
		this.getVueMenuBiblio().getFrame().setVisible(true);
		this.resetVues();
	}

	// Restaure l'état de l'interface avec seule la fenêtre du Menu principal
	// active
	private void resetVues() {
		this.setVueSaisiePeriodique(null);
		this.setVueSaisieOuvrage(null);
		this.setVueConsultOuvrage(null);
		this.setVueSaisieExemplaire(null);
		this.setVueSaisieAuteur(null);
		this.setVueRechercheParAuteur(null);
		this.setVueRechercheMotTitre(null);
	}

	// ************************************************************************************************************
	// Opérations liées à la sérialisation des objets de l'application
	// ************************************************************************************************************
	/**
	 * restauration des objets de l'application
	 */
	public Controleur restaure() {
		try {
			FileInputStream fichier = new FileInputStream("Fsauv.ser");
			ObjectInputStream in = new ObjectInputStream(fichier);
			return ((Controleur) in.readObject());
		} catch (Exception e) {
			Message dialog = new Message("Pbs de Restauration ou fichier non encore créé");

			dialog.setVisible(true);
			return this;
		}
	}

	/**
	 * sauvegarde des objets de l'application
	 */
	private void sauve() {
		try {
			FileOutputStream f = new FileOutputStream("Fsauv.ser");
			ObjectOutputStream out = new ObjectOutputStream(f);
			out.writeObject(this);
		} catch (Exception e) {
			Message dialog = new Message("Pb de Sauvegarde dans le fichier");
			dialog.setVisible(true);
		}
	}

	// ************************************************************************************************************
	// Opérations liées à l'application en réponse à une action de
	// l'utilisateur
	// dans une vue
	// ************************************************************************************************************

	// --------------------------------------------------------------------------------------------------
	// Methode pour Ouvrage
	// --------------------------------------------------------------------------------------------------
	/**
	 * Accès à un ouvrage par son numéro ISBN Invoqué dans VueConsultOuvrage et
	 * VueSaisieExemplaire
	 * 
	 * @param isbn
	 *            le code ISBN de l'ouvrage cherché
	 * @return l'ouvrage qui a l'ISBN indiqué ou null affiche un message
	 *         d'erreur si l'ouvrage n'est pas trouvé
	 */
	public Ouvrage rechOuvrage(String isbn) {
		Ouvrage ouv = this.getOuvrage(isbn);
		if (ouv == null) {
			Message dialog = new Message("Ouvrage inconnu");
			dialog.setVisible(true);
		} else {
			// la vue courante est VueSaisieExemplaire
			if (this.getVueSaisieExemplaire() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage
				ouv.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
				this.getVueSaisieExemplaire().setEtat(Vue.inter1);
				this.getVueSaisieExemplaire().alimente(ouv);
			}
			// la vue courante est VueConsultOuvrage
			if (this.getVueConsultOuvrage() != null) {
				// le contrôleur modifie l'état de la vue
				//this.getVueConsultOuvrage().setEtat(Vue.finale);
				this.getVueConsultOuvrage().alimente(ouv);
			}
			// la vue courante est VueRechercheParAuteur
			if (this.getVueRechercheParAuteur() != null) {
				// le contrôleur modifie l'état de la vue
				this.getVueRechercheParAuteur().setEtat(Vue.finale);
				this.getVueRechercheParAuteur().alimenteOuvrages(ouv);
			}
			// la vue courante est VueRechercheParAuteur
			if (this.getVueRechercheMotTitre() != null) {
			// le contrôleur modifie l'état de la vue
			this.getVueRechercheMotTitre().setEtat(Vue.finale);
			this.getVueRechercheMotTitre().alimenteOuvrages(ouv);
			}

		}
		return ouv;
	} // Fin rechOuvrage
	
	public Ouvrage rechOuvRPA(String isbn) {
		Ouvrage ouv = this.getOuvrage(isbn);
		if (ouv == null) {
			Message dialog = new Message("Ouvrage inconnu");
			dialog.setVisible(true);
		} else {		
			this.consulterOuvrage();
			this.getVueConsultOuvrage().alimente(ouv);
			}
		
		return ouv;
	}
		

	/**
	 * Création d'un exemplaire d'ouvrage Invoqué dans VueSaisieExemplaire
	 * 
	 * @param ouv
	 *            l'ouvrage dateRecep la date de réception de l'exemplaire
	 *            affiche un message de confirmation après l'enregistrement ou
	 *            un message d'erreur
	 */
	public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
		// vérification de la présence de la date et de son format
		if (dateReception.length() == 0) {
			Message dialog = new Message("La date de réception est obligatoire");
			dialog.setVisible(true);
		} else {
			GregorianCalendar date = ESDate.lireDate(dateReception);
			if (date == null) {
				Message dialog = new Message(
						"Le format de la date est incorrect");
				dialog.setVisible(true);
			} else {
				int statutEx;
				if (statut == "empruntable") {
					statutEx = Exemplaire.EMPRUNTABLE;
				} else {
					statutEx = Exemplaire.EN_CONSULTATION;
				}
				// demande d'ajout de l'exemplaire
				Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
				// l'opération s'est bien passée
				if (exemplaire != null) {
					// le contrôleur modifie l'état de la vue
					this.getVueSaisieExemplaire().setEtat(Vue.finale);
					// affichage d'un message de confirmation
					Message dialog = new Message("Exemplaire enregistré");
					dialog.setVisible(true);
				} else {
					Message dialog = new Message(
							"Date de réception incohérente avec la date d'Edition.");
					dialog.setVisible(true);
				}
			}
		}
	} // Fin nouvExemplaire

	/**
	 * Création d'un d'ouvrage Invoqu� dans VueSaisieOuvrage
	 * 
	 * @param dateEdition
	 *            la date d'édition de l'ouvrage affiche un message de
	 *            confirmation après l'enregistrement ou un message d'erreur
	 */
	public void nouvOuvrage(String isbn, String titre, String editeur,
			String dateEdition, Auteur[] auteur) {
		// vérification de la présence des infos obligatoires et du format de
		// la date
		if ((isbn.length() == 0) || (titre.length() == 0)
				|| (editeur.length() == 0) || (dateEdition.length() == 0)) {
			Message dialog = new Message("Tous les champs sont obligatoires");
			dialog.setVisible(true);
		} else if (auteur == null) {
			Message dialog = new Message("Un auteur doit être selectionné");
			dialog.setVisible(true);
		} else {
			GregorianCalendar date = ESDate.lireDate(dateEdition);
			if (date == null) {
				Message dialog = new Message(
						"Le format de la date est incorrect");
				dialog.setVisible(true);
			} else if (this.getOuvrage(isbn) == null) {
				// Instanciation de l'ouvrage
				Ouvrage ouvrage = new Ouvrage(isbn, titre, editeur, date,
						auteur);
				// Ajout de l'ouvrage dans l'ensemble des ouvrages de la
				// biblioth�que
				this.setOuvrage(ouvrage, isbn);
				Message dialog = new Message("Ouvrage enregistré");
				dialog.setVisible(true);
				this.fermerVue(this.getVueSaisieOuvrage());					
			} else {
				Message dialog = new Message("Ouvrage déjà présent");
				dialog.setVisible(true);
			}
		}
	} // Fin nouvOuvrage

	public Ouvrage ouvrageSelec(String chaine) {
	
		if (chaine.length() > 0) {
			Ouvrage ouvrage;
			String isbn = "";			
			Boolean possible = true;
			for(int i=0;i<chaine.length();i++){
				if(chaine.charAt(i) == ' '){
					i=chaine.length()+1;
				} else {
					if(possible){
						isbn += chaine.charAt(i);
						
					}
				}
			}
			ouvrage = this.getOuvrage(isbn);			
			return ouvrage;
		} else {
			Message dialog = new Message("Vous devez selectionner un ouvrage pour pouvoir le consulter.");
			dialog.setVisible(true);
			return null;			
		}		
	}
	
	// --------------------------------------------------------------------------------------------------
	// Methode pour Periodique
	// --------------------------------------------------------------------------------------------------
	public void nouvPeriodique(int num, String issn, String titre) {
		if ((issn.length() == 0) || (titre.length() == 0)) {
			Message dialog = new Message("Tous les champs sont obligatoires");
			dialog.setVisible(true);
		} else {

			if (this.getPeriodique(num) == null) {
				// Instanciation du periodique
				Periodique periodique = new Periodique(issn, titre);
				// Ajout du periodique dans l'ensemble des periodiques de la
				// bibliothèque
				this.setPeriodique(periodique, num);
				Message dialog = new Message("Periodique enregistré");
				dialog.setVisible(true);
				this.fermerVue(this.getVueSaisiePeriodique());
			} else {
				Message dialog = new Message("Ouvrage déjà présent");
				dialog.setVisible(true);
			}
		}
	}

	public Periodique periodiqueSelec(List selection) {
		if (selection.getSelectedIndex() != -1) {
			int num = selection.getSelectedIndex()+1;
			Periodique periodique;			
			periodique = this.getPeriodique(num);
			//this.getVueSaisieParution().setEtat(Vue.inter1);
			//this.getVueConsultPeriodique().setEtat(Vue.inter1);
			return periodique;
		} else {
			Message dialog = new Message("Selectionner un periodique");
			dialog.setVisible(true);
			return null;			
		}

	}
		
	// --------------------------------------------------------------------------------------------------
	// Methode pour Parution
	// --------------------------------------------------------------------------------------------------

	public void nouvParution(Periodique periodique) {
		if (periodique == null) {
			Message dialog = new Message("Tous les champs sont obligatoires");
			dialog.setVisible(true);
		} else {						
				periodique.ajouterParution(periodique.getNbParutions());
				Message dialog = new Message("Parution enregistrée");
				dialog.setVisible(true);
				this.fermerVue(this.getVueSaisieParution());
				this.getVueMenuBiblio().getFrame().setVisible(false);				
		}
	}	
	
	
	public Parution parutionSelec(List selection, Periodique periodique) {
		if (selection.getSelectedIndex() != -1 && periodique != null) {
			int num = selection.getSelectedIndex()+1;
			Parution parution;			
			parution = periodique.getParution(num);	
			this.getVueSaisieParution().setEtat(Vue.finale);
			//this.getVueConsultPeriodique().setEtat(Vue.finale);
			return parution;
		} 
		else {
			Message dialog = new Message("Selectionner une parution");
			dialog.setVisible(true);
			return null;			
		}

	}
	// --------------------------------------------------------------------------------------------------
	// Methode pour Article
	// --------------------------------------------------------------------------------------------------
	
	public void nouvArticle(Parution parution,String titre,String pageDebut,Auteur[] auteur){
		if(parution != null || titre.length()==0 || pageDebut.length()==0){
			if(auteur.length>0){
			Article art = parution.ajouterArticle(pageDebut, titre, auteur);
			for(int i=0;i<parution.getNbArticles();i++){
			this.setArticle(parution.getArticle(i),_articles.size());
			}
			this.setArticle(art, _articles.size());
			Message dialog = new Message("Article ajoute avec succes");
			dialog.setVisible(true);	
			this.getVueSaisieArticle().dispose();			
			}
			else{
				Message dialog = new Message("Article ajoute avec succes");
			dialog.setVisible(true);
			}
		}
		else{
			Message dialog = new Message("Veuillez selectionner un auteur");
			dialog.setVisible(true);
		}
		}		

	
	
	
	public Article rechArticle(Integer idArticle) {
		Article art = this.getArticle(idArticle);
		if (art == null) {
			Message dialog = new Message("Article inconnu");
			dialog.setVisible(true);
		} else {
			// la vue courante est VueSaisieExemplaire
			if (this.getVueRechercheParAuteur() != null) {
				// le contrôleur modifie l'état de la vue
				this.getVueRechercheParAuteur().setEtat(Vue.inter1);
				this.getVueRechercheParAuteur().alimenteArticles(art);
			}
		}
		return art;
	} // Fin rechArticle
	
	// --------------------------------------------------------------------------------------------------
	// Methode pour Auteur
	// --------------------------------------------------------------------------------------------------

	public Auteur[] auteurSelec(String[] selection) {
		Auteur[] auteur = new Auteur[selection.length];
		if(selection.length > 0){			
			for (int i = 0; i < selection.length; i++) {
				Boolean part1 = true;
				String nom = "";
				String prenom = "";
				String nomPrenom = selection[i].toString();				
				if (nomPrenom.equals("")) {
					return null;
				} else
					for (int j = 0; j < nomPrenom.length(); j++) {
						if (nomPrenom.charAt(j) == ' ') {
							part1 = false;
						} else {
							if (!part1) {
								prenom += nomPrenom.charAt(j);
							} else {
								nom += nomPrenom.charAt(j);
							}
						}
					}
				auteur[i] = new Auteur(nom, prenom);
			}
			return auteur;
		}
		else {
			Message dialog = new Message(
					"Au moins un auteur doit être selectionné");
			dialog.setVisible(true);			
			return null;
		}
	}

	public int generationNum() {
		return _auteurs.size() + 1;
	}

	public int rechercheAuteur(String nom) {
		int i = 1;
		Auteur auteur = this.getAuteur(i);
		if (auteur == null) {
			return 0;
		} else {
			while (i < _auteurs.size() && !nom.equals(auteur.getNom())) {
				i++;
				auteur = this.getAuteur(i);
			}
		}
		if (nom.equals(auteur.getNom()))
			return i;
		else
			return 0;
	}

	public void nouvAuteur(String nom, String prenom) {
		if ((nom.length() == 0) || (prenom.length() == 0)) {
			Message dialog = new Message("Tous les champs sont obligatoires");
			dialog.setVisible(true);
		} else {
			if (rechercheAuteur(nom) == 0) {
				Auteur auteur = new Auteur(nom, prenom);
				int num = generationNum();
				this.setAuteur(num, auteur);
				Message dialog = new Message("Auteur enregistré");
				dialog.setVisible(true);
				this.getVueSaisieAuteur().dispose();
				if (this.getVueSaisieOuvrage() != null)
					this.getVueSaisieOuvrage().rafraichissement();
				else if (this.getVueSaisieArticle() != null)
					this.getVueSaisieArticle().rafraichissement();
				
			} else {
				Message dialog = new Message("Auteur déjà présent");
				dialog.setVisible(true);
			}
		}
	}
	
	
	
	/*public String[] TabChaine(String mots){
		System.out.println(mots);
		if (mots.length() > 0) {
			String mot_temp="";
			String[] tabMot = new String[50];			
			int j=0;
			for(int i=0;i<mots.length();i++){
				if(mots.charAt(i) != ' ')
					mot_temp += mots.charAt(i);
				else{
					tabMot[j] = mot_temp;
					System.out.println(tabMot[j]);
					j++;
					mot_temp="";
					i=mots.length()+1;
				}
			}
			return tabMot;
		} else {
			Message dialog = new Message("Vous devez saisir le titre d'un document.");
			dialog.setVisible(true);
			return null;
		}
		
	}*/
	
	/*public void rechercheDocumentsMot(String mots) {		
		String[] tabMot = this.TabChaine(mots);
		if(tabMot != null){
		if(mots != null)
			for(Ouvrage ouv : this.getOuvrages().values()){				
				String[] mot_titre = this.TabChaine(ouv.getTitre());				
				for(int i=0;i<=tabMot.length;i++){					
					for(int j=0;j<=mot_titre.length;j++){
						System.out.println(mot_titre[j]);
						System.out.println(tabMot[i]);
						if(mot_titre[j].equals(tabMot[i]) && mot_titre[j].equals(tabMot[i])){							
							this.rechOuvrage(ouv.getIsbn());
						}
					}
				}
				
			}
		}
			for(Article art : this.getArticles().values()){
				Auteur aut = art.getAuteur();
				for(int i=0;i<auteur.length;i++){
					if(aut.getNom().equals(auteur[i].getNom()) && aut.getPrenom().equals(auteur[i].getPrenom())){
							this.rechArticle(art.getIdArticle());
					}
				}					
			}
		} else if(auteur.length > 1) {
			for(Ouvrage ouv : this.getOuvrages().values()){
				Auteur[] aut = ouv.getTabAuteur();
				Boolean commun = false;
				for(int i=0;i<auteur.length;i++){
					for(int j=0;j<aut.length;j++){
						if(aut[j].getNom().equals(auteur[i].getNom()) && aut[j].getPrenom().equals(auteur[i].getPrenom()))
							commun = true;
						else
							commun = false;
					}
				}
				if(commun)
					this.rechOuvrage(ouv.getIsbn());
			}
			/*for(Article art : this.getArticles().values()){
				Auteur aut = art.getAuteur();
				for(int i=0;i<auteur.length;i++){
					if(aut.getNom().equals(auteur[i].getNom()) && aut.getPrenom().equals(auteur[i].getPrenom())){
						commun = true;
					else
						commun = false;
					}
				}
				if(commun)
					this.rechOuvrage(ouv.getIsbn());
			}
		}*/
	
	public void rechercheDocumentsMot(String mots) {
		if(mots != null)
			for(Ouvrage ouv : this.getOuvrages().values()){	
				if(mots.equals(ouv.getTitre())){
					this.rechOuvrage(ouv.getIsbn());
				}
			}
			for(Article art : this.getArticles().values()){	
				if(mots.equals(art.getTitre())){
					this.rechArticle(art.getIdArticle());
				}
			}
			
	}
	public void rechercheDocuments(Auteur[] auteur) {		
		if(auteur.length == 1){
			for(Ouvrage ouv : this.getOuvrages().values()){				
				Auteur[] aut = ouv.getTabAuteur();				
				for(int i=0;i<auteur.length;i++){					
					for(int j=0;j<aut.length;j++){						
						if(aut[j].getNom().equals(auteur[i].getNom()) && aut[j].getPrenom().equals(auteur[i].getPrenom())){							
							this.rechOuvrage(ouv.getIsbn());
						}
					}
				}
			}
			for(Article art : this.getArticles().values()){
				Auteur[] aut = art.getAuteur();				
				for(int i=0;i<aut.length;i++){
					if(aut[i].getNom().equals(auteur[0].getNom()) && aut[i].getPrenom().equals(auteur[0].getPrenom())){
							this.rechArticle(art.getIdArticle());
					}
				}					
			}
		} else if(auteur.length > 1) {
			for(Ouvrage ouv : this.getOuvrages().values()){
				Auteur[] aut = ouv.getTabAuteur();
				Boolean commun = false;
				for(int i=0;i<auteur.length;i++){
					for(int j=0;j<aut.length;j++){
						if(aut[j].getNom().equals(auteur[i].getNom()) && aut[j].getPrenom().equals(auteur[i].getPrenom()))
							commun = true;
						else
							commun = false;
					}
				}
				if(commun)
					this.rechOuvrage(ouv.getIsbn());
			}
			for(Article art : this.getArticles().values()){
				Auteur[] aut = art.getAuteur();
				Boolean commun = false;
				for(int i=0;i<auteur.length;i++){
					for(int j=0;j<aut.length;j++){
					if(aut[j].getNom().equals(auteur[i].getNom()) && aut[j].getPrenom().equals(auteur[i].getPrenom()))
						commun = true;
					else
						commun = false;		
					}
				}
				if(commun)
					this.rechArticle(art.getIdArticle());
			}
		}

	}
}								
						
			
			
				
		 
		
	
